\input macros
\def\bookline{\CLOS\  Specification}
\def\chapline{Glossary}

\beginChapter 4.{Common Lisp Object System Specification}%
{Glossary}{Glossary}
\endTitlePage

\beginSection{Introduction}

This section defines the terminology used in this document.

\endSection%{Introduction}

\beginSection{Glossary}

{\bit Accessor function\/}: 

A generic function that enables you to read the value of a slot.  {\bf
setf} may be used with an accessor function to write the value of the
slot.   {\bf defclass} has an option for automatically generating
accessor functions for slots.

{\bit Class\/}:     

An object that describes the structure and behavior of a set of objects.
All Lisp objects have a class, and can be queried for the class by using
the {\bf class-of} function.

{\bit Classical method\/}:

Method selection is based on the class of the first argument to the
generic function (that is, on the class of a single object).

{\bit Components\/}:

The components of a class include:  the class itself, the superclasses
of the class, the superclasses of the superclasses of the class, and
so on.

{\bit Default method\/}:

A default method does not specify any type for discrimination purposes,
or specifies the type as {\bf t}.  A default method is selected when no
more specific method for the generic function is defined.

{\bit Dispatching\/}:

The process of selecting one or more methods to run to perform a generic
function, based on the class of its specialized arguments.

{\bit Generic Function\/}:

A function that has methods defined for it.  Ordinary functions have a
single definition; generic functions have a distributed definition.  The
implementation of an ordinary function is the same whenever the function
is called.  The implementation of a generic function varies from call to
call, depending on the classes of its arguments.

{\bit Instance\/}:  

Every object is an instance of some class.  The term instance is used to
describe the instance/class relationship of an object to its class.

{\bit Metaclass\/}: 

Each object has a class.  A class itself is an object which has a class.
The metaclass of an object is the class of the class of the object.

A metaclass itself is an object, which has a class.  The term metaclass
is used to refer to a class that is suitable for being the class of a
class.  An instance of a metaclass is a class.

{\bit Method\/}:

An object that describes how to perform a generic function for a given
set of arguments.  One or more methods are selected according to the
classes of the arguments to the generic function. 

{\bit Multi-method\/}:

The dispatching is based on two or more arguments to the generic
function (that is, on the class of several objects).

{\bit Object\/}:

Any Lisp datum, such as a number, a character, or an instance. 

{\bit Reader function\/}:

A generic function that enables you to read the value of a slot.
{\bf defclass} has an option for automatically generating accessor
functions for slots. 

{\bit SETF generic function\/}:

A {\bf setf} generic function is the function that is called when you
evaluate an expression such as:  ({\bf setf} ({\it g ...\/}) {\it
value\/}), where {\it g\/} is any generic function.   One example of
{\it g\/} is a slot accessor.

{\bit SETF method\/}:

A method for a {\bf setf} generic function.  

{\bit Slots\/}:

Slots define the structure of instances of the class, as do
defstruct slots.  When defining a new class, you specify the
slots of the class.  An {\bf :instance} slot is a place where you can
store data inside an instance.  This is the most commonly used
kind of slot, where each instance has an individual slot of the
same name.  A {\bf :class} slot is a place where you can store data
inside a class.  There is only one slot, whose value is shared by
all instances of the class.

{\bit Standard-type-class\/}: 

A standard-type-class is a class that corresponds to a predefined Common
Lisp type specifier.  For example {\bf array} is a standard-type-class; 
{\bf array} is the name of the class for objects of type {\bf array}.  

Each standard-type-class has the class {\bf standard-type-class} as a
component.  Users can write methods that dispatch on any primitive Lisp
type that has a corresponding class.  However, it is not allowed to make
an instance of a standard-type-class with {\bf make-instance}, or to
include a standard-type-class as a superclass of a class.

{\bit Superclass\/}:

The superclasses of a class are those classes that are included
explicitly in the superclass list in the DEFCLASS form.  Each
superclass is an integral part of a class.  The class inherits
characteristics (such as slots) and behavior (such as methods)
from each of its superclasses.  This is the primary mechanism
for program modularity.  A typical mode of use is to define
several basic classes and combine them to achieve specialized
behavior.

\endSection%{Glossary}


\endSection

\endChapter
\bye